package com.thermal.thermal_inspection.service.impl;

import com.thermal.thermal_inspection.entity.Classes;
import com.thermal.thermal_inspection.mapper.ClassMapper;
import com.thermal.thermal_inspection.service.UtilService;
import com.thermal.thermal_inspection.vo.ClassMemberVo;
import com.thermal.thermal_inspection.vo.MemBerVo;
import lombok.Data;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.apache.poi.ss.usermodel.*;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class UtilServiceImpl implements UtilService {
    @Value("${app.schedule-path}")
    private String scheduleDirPath;
    @Autowired
    private ClassMapper classMapper;
    /**
     * 判断排班表里面的班组是否都存在
     * @return boolean
     */
    @Override
    public boolean isExistClass() {
        String filePath = scheduleDirPath + "/schedule.xlsx";

        // 获取所有班组的 classId 列表
        List<Integer> classIdList = classMapper.getClasses().stream()
                .map(Classes::getClassId)
                .collect(Collectors.toList());

        Set<Integer> groupIdsInExcel = new HashSet<>();

        try (FileInputStream fis = new FileInputStream(new File(filePath));
             Workbook workbook = new XSSFWorkbook(fis)) {

            Sheet sheet = workbook.getSheetAt(0);

            // 遍历每一行，跳过标题行
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                Row row = sheet.getRow(i);

                if (row != null) {
                    Cell cell = row.getCell(3); // 假设 group_id 在第4列（索引为3）

                    if (cell != null && cell.getCellType() == CellType.NUMERIC) {
                        int groupId = (int) cell.getNumericCellValue();
                        groupIdsInExcel.add(groupId);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        // 检查所有 group_id 是否都存在于 classIdList 中
        return classIdList.containsAll(groupIdsInExcel);
    }

    /**
     * 计算两个时间字符串之间的小时差，并向上取整
     *
     * @param startTime 开始时间字符串
     * @param endTime   结束时间字符串
     * @return 向上取整后的小时数
     */
    @Override
    public int calculateRoundedHours(String startTime, String endTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // 时间格式

        // 解析时间字符串为 LocalDateTime
        LocalDateTime start = LocalDateTime.parse(startTime, formatter);
        LocalDateTime end = LocalDateTime.parse(endTime, formatter);

        // 计算时间差
        long minutesDiff = Duration.between(start, end).toMinutes(); // 获取总分钟数
        double hoursDiff = (double) minutesDiff / 60; // 转换为小时（浮点数）

        // 向上取整并返回
        return (int) Math.ceil(hoursDiff); // 向上取整并转换为整数
    }
    /**
     * 将时间字符串转换为 SQL Timestamp
     *
     * @param timeString 时间字符串
     * @return SQL Timestamp 对象
     */
    @Override
    public  Timestamp convertToTimestamp(String timeString) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // 时间格式
        LocalDateTime localDateTime = LocalDateTime.parse(timeString, formatter); // 解析字符串
        return Timestamp.valueOf(localDateTime); // 转换为 SQL Timestamp
    }
    /**
     * 获取指定 classId 的 memberDetailVO 列表
     *
     * @param classMemberVos List<ClassMemberVo> 列表
     * @param classId       要查找的 classId
     * @return 对应 classId 的 memberDetailVO 列表，如果没有找到则返回 null 或空列表
     */
    @Override
    public List<MemBerVo> getMemberDetailByClassId(List<ClassMemberVo> classMemberVos, int classId) {
        // 使用流 API 筛选并获取 memberDetailVO
        Optional<List<MemBerVo>> memberDetailVO = classMemberVos.stream()
                .filter(cm -> cm.getClassId() == classId) // 筛选出 classId 匹配的对象
                .map(ClassMemberVo::getMemberDetailVO) // 获取对应的 memberDetailVO
                .findFirst(); // 取第一个匹配的结果

        // 返回找到的 memberDetailVO，若未找到则返回 null
        return memberDetailVO.orElse(null);
    }
    /**
     * 获取指定 inspectionDataId 的 MemBerVo 对象
     *
     * @param memberVos         List<MemBerVo> 列表
     * @param inspectionDataId  要查找的 inspectionDataId
     * @return 对应 inspectionDataId 的 MemBerVo 对象，如果没有找到则返回 null
     */
    @Override
    public MemBerVo getMemberByInspectionDataId(List<MemBerVo> memberVos, int inspectionDataId) {
        // 使用流 API 筛选并获取 MemBerVo
        Optional<MemBerVo> memberVo = memberVos.stream()
                .filter(m -> m.getInspectionDataId() == inspectionDataId) // 筛选出 inspectionDataId 匹配的对象
                .findFirst(); // 取第一个匹配的结果

        // 返回找到的 MemBerVo，若未找到则返回 null
        return memberVo.orElse(null);
    }
    /**
     * 根据单元格类型获取字符串值
     *
     * @param cell Excel单元格
     * @return 返回单元格的字符串表示
     */
    @Override
    public String getCellStringValue(Cell cell) {
        if (cell == null) {
            return null;
        }

        // 检查单元格类型
        if (cell.getCellType() == CellType.STRING) {
            return cell.getStringCellValue();
        } else if (cell.getCellType() == CellType.NUMERIC) {
            // 如果是数值类型，将数值转换为字符串
            return String.valueOf(cell.getNumericCellValue());
        } else {
            return cell.toString(); // 对于其他类型，返回默认字符串表示
        }
    }

    /**
     * 判断排班表是否存在
     * @return boolean
     */
    @Override
    public boolean isExistScheduleExcel() {
        String filePath = scheduleDirPath + "/schedule.xlsx";
        File file = new File(filePath);

        // 检查文件是否存在
        if (!file.exists() || !file.isFile()) {
            return false;
        }
        return true;
    }
    /**
     * 判断当前时间是否在开始时间和结束时间之前
     * @param batchStartTime
     * @param batchEndTime
     * @return boolean
     */
    @Override
    public boolean isFutureBatch(Timestamp batchStartTime, Timestamp batchEndTime, Timestamp inspectionStartTime) {
        LocalDate currentDate = LocalDate.now();

        // 转换 batchStartTime 和 batchEndTime 到 LocalDate
        LocalDate startDate = batchStartTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate endDate = batchEndTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

        // 获取 inspectionStartTime 的时分秒部分
        LocalTime inspectionTime = inspectionStartTime.toInstant().atZone(ZoneId.systemDefault()).toLocalTime();

        // 组合新的时间对象
        LocalDateTime combinedStartDateTime = LocalDateTime.of(startDate, inspectionTime);
        LocalDateTime combinedEndDateTime = LocalDateTime.of(endDate, inspectionTime);

        // 获取当前时间的年月日并组合时分秒为当天的时间
        LocalDateTime currentDateTime = LocalDateTime.now();

        // 输出两个时间
        System.out.println("Combined Start DateTime: " + combinedStartDateTime);
        System.out.println("Combined End DateTime: " + combinedEndDateTime);

        // 检查组合的 batchStartTime 和 batchEndTime 是否都大于等于当前时间的年月日
        return !combinedStartDateTime.isBefore(currentDateTime) &&
                !combinedEndDateTime.isBefore(currentDateTime);
    }
}
